package com.fh.util;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;

public class FileUtil {

	public static void main(String[] args) {
		String dirName = "d:/FH/topic/";// 创建目录
		FileUtil.createDir(dirName);
	}

	/**
	 * 创建目录
	 * 
	 * @param destDirName
	 *            目标目录名
	 * @return 目录创建成功返回true，否则返回false
	 */
	public static boolean createDir(String destDirName) {
		File dir = new File(destDirName);
		if (dir.exists()) {
			return false;
		}
		if (!destDirName.endsWith(File.separator)) {
			destDirName = destDirName + File.separator;
		}
		// 创建单个目录
		if (dir.mkdirs()) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 删除文件
	 * 
	 * @param filePathAndName
	 *            String 文件路径及名称 如c:/fqf.txt
	 * @param fileContent
	 *            String
	 * @return boolean
	 */
	public static void delFile(String filePathAndName) {
		File file = new File(filePathAndName);
		try {
			if (file.exists()) {//判断文件是否存在  
				if (file.isFile()) {//判断是否是文件  
					file.delete();//删除文件   
				} else if (file.isDirectory()) {//否则如果它是一个目录  
					File[] files = file.listFiles();//声明目录下所有的文件 files[];  
					for (int i = 0;i < files.length;i ++) {//遍历目录下所有的文件  
						files[i].delete();//把所有文件删除
					}  
					file.delete();//删除文件夹  
				}  
			} else {  
				System.out.println("所删除的文件不存在");  
			}
		} catch (Exception e) {
			System.out.println("删除文件操作出错");
			e.printStackTrace();
		}
	}

/**
 * 读取到字节数组0
 * 
 * @param filePath //路径
 * @throws IOException
 */
public static byte[] getContent(String filePath) throws IOException {
	File file = new File(filePath);
	long fileSize = file.length();
	if (fileSize > Integer.MAX_VALUE) {
		System.out.println("file too big...");
		return null;
	}
	FileInputStream fi = new FileInputStream(file);
	byte[] buffer = new byte[(int) fileSize];
	int offset = 0;
	int numRead = 0;
	while (offset < buffer.length
			&& (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {
		offset += numRead;
	}
	// 确保所有数据均被读取
	if (offset != buffer.length) {
		throw new IOException("Could not completely read file "
				+ file.getName());
	}
	fi.close();
	return buffer;
}

/**
 * 读取到字节数组1
 * 
 * @param filePath
 * @return
 * @throws IOException
 */
public static byte[] toByteArray(String filePath) throws IOException {

	File f = new File(filePath);
	if (!f.exists()) {
		throw new FileNotFoundException(filePath);
	}
	ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length());
	BufferedInputStream in = null;
	try {
		in = new BufferedInputStream(new FileInputStream(f));
		int buf_size = 1024;
		byte[] buffer = new byte[buf_size];
		int len = 0;
		while (-1 != (len = in.read(buffer, 0, buf_size))) {
			bos.write(buffer, 0, len);
		}
		return bos.toByteArray();
	} catch (IOException e) {
		e.printStackTrace();
		throw e;
	} finally {
		try {
			in.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		bos.close();
	}
}

/**
 * 读取到字节数组2
 * 
 * @param filePath
 * @return
 * @throws IOException
 */
public static byte[] toByteArray2(String filePath) throws IOException {

	File f = new File(filePath);
	if (!f.exists()) {
		throw new FileNotFoundException(filePath);
	}

	FileChannel channel = null;
	FileInputStream fs = null;
	try {
		fs = new FileInputStream(f);
		channel = fs.getChannel();
		ByteBuffer byteBuffer = ByteBuffer.allocate((int) channel.size());
		while ((channel.read(byteBuffer)) > 0) {
			// do nothing
			// System.out.println("reading");
		}
		return byteBuffer.array();
	} catch (IOException e) {
		e.printStackTrace();
		throw e;
	} finally {
		try {
			channel.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			fs.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

/**
 * Mapped File way MappedByteBuffer 可以在处理大文件时，提升性能
 * 
 * @param filename
 * @return
 * @throws IOException
 */
public static byte[] toByteArray3(String filePath) throws IOException {

	FileChannel fc = null;
	RandomAccessFile rf = null;
	try {
		rf = new RandomAccessFile(filePath, "r");
		fc = rf.getChannel();
		MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0,
				fc.size()).load();
		//System.out.println(byteBuffer.isLoaded());
		byte[] result = new byte[(int) fc.size()];
		if (byteBuffer.remaining() > 0) {
			// System.out.println("remain");
			byteBuffer.get(result, 0, byteBuffer.remaining());
		}
		return result;
	} catch (IOException e) {
		e.printStackTrace();
		throw e;
	} finally {
		try {
			rf.close();
			fc.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

/** 
 * 复制一个目录及其子目录、文件到另外一个目录 
 * @param src 
 * @param dest 
 * @throws IOException 
 */  
public static void copyFolder(File src, File dest) throws IOException {  
	if (src.isDirectory()) {  
		if (!dest.exists()) {  
			dest.mkdir();  
		}  
		String files[] = src.list();  
		for (String file : files) {  
			File srcFile = new File(src, file);  
			File destFile = new File(dest, file);  
			// 递归复制  
			copyFolder(srcFile, destFile);  
		}  
	} else {  
		InputStream in = new FileInputStream(src);  
		OutputStream out = new FileOutputStream(dest);  

		byte[] buffer = new byte[1024];  

		int length;  

		while ((length = in.read(buffer)) > 0) {  
			out.write(buffer, 0, length);  
		}  
		in.close();  
		out.close();  
	}  
} 

/**
 * 复制单个文件
 * @param oldPath String 原文件路径 如：c:/fqf.txt
 * @param newPath String 复制后路径 如：f:/fqf.txt
 * @return boolean
 */
public static void copyFile(String oldPath, String newPath) {
	try {
		int bytesum = 0;
		int byteread = 0;
		File oldfile = new File(oldPath);
		if (oldfile.exists()) { //文件存在时
			InputStream inStream = new FileInputStream(oldPath); //读入原文件
			FileOutputStream fs = new FileOutputStream(newPath);
			byte[] buffer = new byte[1444];
			while ( (byteread = inStream.read(buffer)) != -1) {
				bytesum += byteread; //字节数 文件大小
				fs.write(buffer, 0, byteread);
			}
			inStream.close();
		}
	}
	catch (Exception e) {
		e.printStackTrace();
	} 

}
}